package class8;

class Person
{
    int a;
    public void print()
    {
        System.out.println("Person");
    }
}
class Student extends Person
{
    int b;
    public void print()
    {
        System.out.println("Student");
    }

    public void student()
    {
        System.out.println("Student特有函数");
    }
}

class Teacher extends Person
{
    int c;
    public void print()
    {
        System.out.println("Teacher");
    }
    public void teacher()
    {
        System.out.println("Teacher特有函数");
    }
}


final class testfinal//final修饰的类不能被继承，这与C++11相同
{
    public static final String str="Hello,Java!";//静态常量，属于类的
    //静态常量一般建议大写，多个单词用下划线连接
    
    public final void print()//final修饰的方法不能被重写
    {
        System.out.println("final方法");
    }

    final int a=10;//java中没有const，使用final修饰变量表示常量，只能赋值一次！
//    a=20;//错误，final修饰的变量不能被修改
    final int[] arr={1,2,3};//final修饰的数组，数组名不能被修改，但是数组元素可以被修改
//    arr=Null;//错误，数组名不能被修改
}

//class testfinall extends testfinal//错误，final类不能被继承

public class oop_3 {
    public static void testoop(Person p)
    {
        p.print();//多态并没有问题，但如果想访问子类特有的函数就不行了
        //p.student();//错误，父类引用不能访问子类特有的函数
        //这时就需要类型转换
        if(p instanceof Student)//判断p是否是Student类型，instanceof用于判断对象是否是某个类或其子类的实例。
        {
            ((Student) p).student();//强制类型转换
        }
        else if(p instanceof Teacher)
        {
            ((Teacher) p).teacher();
        }
    }

    public static void main(String[] args) {
        //这里来学习java多态
        //多态是在继承/实现情况下的一种现象，表现为对象多态，行为多态
        A a=new A();//父类的引用指向父类对象
        A b=new B();//父类的引用指向子类对象
        B c=new B();//子类的引用指向子类对象
//      B d=new A();//错误，子类的引用不能指向父类对象
        //哈哈跟C++一样，必须是父类引用或者指针指向子类对象
        //多态的前提：有继承/实现的关系；存在父类引用子类对象；存在方法的重写
        //多态的好处：提高了代码的扩展性和维护性
        a.print();
        System.out.println(a.a);
        b.print();
        System.out.println(b.a);
        //成员变量并没有多态,以及静态成员函数也没有多态，

        Student s=new Student();
        Teacher t=new Teacher();
        testoop(s);
        testoop(t);
    }


}
